/* =============================================================================
PROJET           : c-social-network
NOM DU FICHIER   : personne.h
OBJET            : Header du module personne.
--------------------------------------------------------------------------------
DATE DE CREATION : 27/04/10
AUTEUR           : Benjamin MICHEL
--------------------------------------------------------------------------------
MODIFICATIONS (   n) date - auteur - description )
    1) 27/04/10 - Benjamin MICHEL - création de la structure, et des fonctions
    2) 28/04/10 - Benjamin MICHEL - rajout de la fonction is_identique
    3) 28/04/10 - Benjamin MICHEL - Ajout de la fonction destroy
    4) 30/04/10 - Benjamin MICHEL - Création d'une structure externe
    5) 07/05/10 - Benjamin MICHEL - fonction add_rel
    6) 07/05/10 - Benjamin MICHEL / PUECHLONG Joris- ajout des etats
    7) 09/05/10 - Joris PUECHLONG - ajout des fonctions utilisatant les etats
    8) 18/05/10 - Joris PUECHLONG - ajout de conf_dual et des fonctions
============================================================================= */
#ifndef H_PERSONNE
#define H_PERSONNE

#include "../liste/liste.h"

/*taille maximale d'une personne*/
#include "../def.h"

/*==============================================================================
structure t_personne
    id: numéro d'identité d'une personne
    nom: le nom d'une personne de taille maximale MAX_NOM_PERSONNE
    frequence: la fréquence à laquelle une personne vérifie son compte
    conf: la liste de personne en qui la personne fait confiance
    marque: la marque pour une personne (-1 ou 0 ou 1)
	distance: la distance entre une personne, et une autre
	pere: un pointeur sur le pere de la personne (utilise dans les algos)


IMPORTANT!
--require:
--  initialisation:
--      t_personne *<nom_instance> = NULL;
*/
typedef struct _personne t_personne;

struct _personne{
    int id;
    char nom[MAX_NOM_PERSONNE];
    int frequence;
    struct liste *conf;
    short int marque;
	int distance;
	t_personne *pere;
};




/*=============================================================================
exportation du module PERSONNE

usage dans module extern:
    #include personne.h
    f_personne.<nom_fonction>;
*/
extern struct _PERSONNE{

    /*
    function creer_vide return t_personne*;
    cree une t_personne avec aucune informations

    --ensure:
    --	is_vide(creer_vide()) == VRAIS
    */
    t_personne* (*const creer_vide) (void);


    /*
    function creer(IN: int id, char[MAX_NOM_PERSONNE] nom, int frequence) return t_personne*;
    cree une t_personne avec les données passées en paramètre

    --ensure:
    --  t_personne *pers;
    --  pers=creer(id, nom, freq);
    --  get_id(pers) == id;
    --  get_nom(pers) == nom;
    --  get_frequence(pers) == freq;
    */
    t_personne* (*const creer) (int, char[MAX_NOM_PERSONNE], int);


    /*
    function is_vide(IN: t_personne * pers) return Boolean;
    Vrais si t_personne est vide, faux sinon

    --ensure:
    --  is_vide(creer_vide()) == VRAIS
    --  AND
    --  is_vide(creer(id, nom, freq)) == FAUX
    */
    int (*const is_vide) (const t_personne*);


    /*
    function get_id(IN: t_personne* pers) return int;
    renvoie l'id de la t_personne

    --require:
    --  pers != NULL
    */
    int (*const get_id) (const t_personne *);


    /*
    procedure get_nom(IN: t_personne* pers, OUT: char ** nom);
    assigne le nom de la t_personne à la chaine de char donnée en paramètre

    --require:
    --  pers != NULL
    --  nom == NULL
    --  desalouer le pointeur après usage
    */
    void (*const get_nom) (const t_personne *, char **);


    /*
    function get_frequence(IN: t_personne * pers) return int;
    renvoie la fréquence de vérification de son compte de la t_personne

    --require:
    --  pers != NULL
    */
    int (*const get_frequence) (const t_personne *);

    /*
    function get_conf(IN: t_personne *pers) return t_liste;
    renvoie les conf (si int=1)  ou conf_dual (si int = 2) de la personne de la personne

    --require:
    --  pers != NULL
    --  int = 1 ou int = 2
    --note:
    */
    struct liste *(*const get_conf) (t_personne *);

    /*
    function is_identique(IN: t_personne* pers1, t_personne* pers2) return bool;
    renvoie TRUE si ils pointent vers la même personne, faux sinon

    --ensure:
    --  t_personne *pers1, *pers2;
    --  ...
    --  is_identique(pers1, pers2) == TRUE >> pers1 et pers2 pointent vers la même personne
    */
    int (*const is_identique) (const t_personne *, const t_personne *);

	/*
	procedure add_rel(IN OUT: t_personne* pers1, IN: t_personne* pers2);
	ajoute pers2 dans la liste des personnes qui font confiance à la personne 1
	et l'inverse dans conf_dual

	--require:
	--	is_vide(pers1) == false
	--	is_vide(pers2) == false
	*/
	void (*const add_rel) (t_personne *, t_personne *);

    /*
    procedure destroy(OUT: t_personne* pers);
    Détruit la pers, et libère la mémoire

    --ensure:
    --  pers == NULL
    */
    void (*const destroy) (t_personne **);


    /*
    procedure marque(IN OUT: t_personne);
    Marque la personne

    --require:
    --  personne non vide
    */
    void (*const marque_nouv) (t_personne *);


    /*
    procedure marque(IN OUT: t_personne);
    Marque la personne

    --require:
    --  personne non vide
    */
    void (*const marque) (t_personne *);

    /*
    function is_marque(IN: t_personne) return Bool;
    Indique si la personne est (marquee)
    si elle est vue => faux

    --require:
    --  personne non vide
    */
    int (*const is_marque) (t_personne *);

    /*
    function marque_vu(IN OUT: t_personne);
    Marque la personne comme vue
    */
    void (*const marque_vu) (t_personne *);

    /*
    function is_vu(IN: t_personne)return Bool;
    Indique si la personne est vue
    si elle est marquee => vrais

    --require:
    --  personne non vide
    */
    int (*const is_vu) (t_personne *);

	/*
	function get_distance(IN: t_personne)return INT;
	*/
	int (*const get_distance) (t_personne *);

	/*
	procedure set_distance(OUT: t_personne);
	*/
	void (*const set_distance) (t_personne *, int);

	/*
	function get_pere(IN: t_personne)return INT;
	*/
	t_personne *(*const get_pere) (t_personne *);

	/*
	procedure set_pere(OUT: t_personne);
	*/
	void (*const set_pere) (t_personne *, t_personne *);

/*
Déclaration des fonction du module dans la structure f_personne
*/
}f_personne;

#endif

